/**
 * 良田高拍仪工具类
 * 基于良田 WebSocket API 的集成
 * 支持良田高拍仪的拍摄、视频预览、条码识别、身份证读取等功能
 */

import { ElMessage } from 'element-plus';

/**
 * 高拍仪配置接口
 */
export interface ScannerConfig {
  /** WebSocket地址，自动根据页面协议选择 WS 或 WSS */
  wsUrl?: string;
  /** 默认摄像头索引 (0=主摄像头, 1=副摄像头) */
  defaultCameraIndex?: number;
  /** 图片质量 (0-5)，默认 3，数值越大质量越高 */
  quality?: number;
  /** 旋转角度 (0, 90, 180, 270)，默认 0 */
  rotate?: number;
  /** 颜色模式 (0=彩色, 1=灰度, 2=黑白)，默认 0 */
  colorMode?: number;
  /** 是否裁切页面，默认 0 */
  cutPage?: number;
  /** WebSocket 连接超时时间（毫秒），默认 5000 */
  connectionTimeout?: number;
  /** 命令响应超时时间（毫秒），默认 10000 */
  commandTimeout?: number;
}

/**
 * 获取默认的 WebSocket 地址，只有ws地址
 */
function getDefaultWebSocketUrl(): string {
  // 服务端渲染环境：默认使用 WS
  return 'ws://127.0.0.1:9000';
}

/**
 * 拍摄结果接口
 */
export interface CaptureResult {
  /** 是否成功 */
  success: boolean;
  /** Base64图片数据 */
  imageData?: string;
  /** 错误信息 */
  error?: string;
  /** 文件名 */
  fileName?: string;
  /** 文件路径（如果保存到本地） */
  filePath?: string;
}

/**
 * 设备信息接口
 */
export interface DeviceInfo {
  /** 设备名称 */
  name: string;
  /** 设备索引 */
  index: number;
  /** 设备状态 (no=未连接, ok=已连接, run=运行中) */
  status: string;
  /** 是否在线 */
  online: boolean;
}

/**
 * 身份证信息接口
 */
export interface IDCardInfo {
  /** 姓名 */
  name: string;
  /** 性别 */
  sex: string;
  /** 性别代码 */
  sexCode: string;
  /** 民族代码 */
  nationCode: string;
  /** 生日 */
  birthday: string;
  /** 地址 */
  address: string;
  /** 身份证号码 */
  cardID: string;
  /** 发卡机构 */
  issueOrgan: string;
  /** 有效起始日期 */
  validStart: string;
  /** 有效终止日期 */
  validEnd: string;
  /** 身份证UID */
  strIDUID: string;
  /** 附加信息 */
  appendMsg: string;
  /** 照片Base64 */
  photoBase64: string;
  /** 正面照片Base64 */
  photoBase64_Z: string;
  /** 反面照片Base64 */
  photoBase64_F: string;
}

/**
 * WebSocket 消息接口
 */
interface WebSocketMessage {
  function: string;
  [key: string]: any;
}

/**
 * WebSocket 响应接口
 */
interface WebSocketResponse<T = any> {
  ret: number;
  function?: string;
  value?: T;
  message?: string;
  [key: string]: any;
}

/**
 * 良田高拍仪类
 */
export class LiangtianScanner {
  private config: Required<ScannerConfig>;
  private ws: WebSocket | null = null;
  private isConnected: boolean = false;
  private messageHandlers: Map<string, (response: WebSocketResponse) => void> = new Map();
  private videoStreamCallback: ((base64: string) => void) | null = null; // 视频流回调

  constructor(config: ScannerConfig = {}) {
    this.config = {
      wsUrl: config.wsUrl || getDefaultWebSocketUrl(),
      defaultCameraIndex: config.defaultCameraIndex ?? 0,
      quality: config.quality ?? 3,
      rotate: config.rotate ?? 0,
      colorMode: config.colorMode ?? 0,
      cutPage: config.cutPage ?? 0,
      connectionTimeout: config.connectionTimeout ?? 5000,
      commandTimeout: config.commandTimeout ?? 10000,
    };
  }

  /**
   * 建立 WebSocket 连接并自动初始化设备
   */
  private connect(): Promise<void> {
    return new Promise((resolve, reject) => {
      try {
        this.ws = new WebSocket(this.config.wsUrl);

        const timeout = setTimeout(() => {
          if (!this.isConnected) {
            this.disconnect();
            reject(new Error('连接高拍仪服务超时'));
          }
        }, this.config.connectionTimeout);

        this.ws.onopen = () => {
          clearTimeout(timeout);
          this.isConnected = true;
          //console.log('✅ 高拍仪服务连接成功');
          
          // 连接成功后自动初始化设备（参考 demo）
          // 初始化是异步的，但不等待结果，直接 resolve
          setTimeout(() => {
            try {
              const initMsg = { function: 'InitDevs' };
              this.ws?.send(JSON.stringify(initMsg));
              //console.log('📡 已发送设备初始化命令');
            } catch (error) {
              //console.error('发送初始化命令失败:', error);
            }
          }, 100); // 稍微延迟，确保连接稳定
          
          resolve();
        };

        this.ws.onerror = (error) => {
          clearTimeout(timeout);
          //console.error('❌ WebSocket 连接错误:', error);
          reject(new Error('无法连接到高拍仪服务，请确保服务已启动'));
        };

        this.ws.onclose = () => {
          this.isConnected = false;
          //console.log('🔌 高拍仪服务连接已关闭');
        };

        this.ws.onmessage = (event) => {
          this.handleMessage(event.data);
        };
      } catch (error) {
        reject(error);
      }
    });
  }

  /**
   * 处理接收到的消息
   */
  private handleMessage(data: string): void {
    try {
      const response: WebSocketResponse = JSON.parse(data);
      const functionName = response.function;
      
      // 特殊处理：ImageCallback 是视频流回调
      if (functionName === 'ImageCallback') {
        if (this.videoStreamCallback && response.value) {
          this.videoStreamCallback(response.value);
        }
        return;
      }
      
      if (functionName && this.messageHandlers.has(functionName)) {
        const handler = this.messageHandlers.get(functionName);
        handler?.(response);
        this.messageHandlers.delete(functionName);
      }
    } catch (error) {
      //console.error('解析消息失败:', error);
    }
  }

  /**
   * 发送 WebSocket 消息（自动管理连接）
   */
  private async sendMessage<T = any>(
    functionName: string,
    params?: any
  ): Promise<WebSocketResponse<T>> {
    // 每次发送前建立新连接
    await this.connect();

    return new Promise((resolve, reject) => {
      const message: WebSocketMessage = {
        function: functionName,
        ...params,
      };

      // 设置超时
      const timeout = setTimeout(() => {
        this.messageHandlers.delete(functionName);
        this.disconnect(); // 超时后断开连接
        reject(new Error(`命令执行超时: ${functionName}`));
      }, this.config.commandTimeout);

      // 注册消息处理器
      this.messageHandlers.set(functionName, (response: WebSocketResponse<T>) => {
        clearTimeout(timeout);
        resolve(response);
        // 响应后不立即断开，等待外部调用 disconnect
      });

      // 发送消息
      try {
        this.ws?.send(JSON.stringify(message));
      } catch (error: any) {
        clearTimeout(timeout);
        this.messageHandlers.delete(functionName);
        this.disconnect(); // 发送失败后断开连接
        reject(new Error(error.message || '发送消息失败'));
      }
    });
  }

  /**
   * 检查设备连接状态（用完后自动断开）
   */
  async checkConnection(): Promise<boolean> {
    try {
      const response = await this.sendMessage('GetDeviceCount');
      const deviceCount = parseInt(response.value || '0');
      const isConnected = deviceCount > 0 && response.ret === 0;
      this.disconnect(); // 检查完立即断开
      return isConnected;
    } catch (error) {
      //console.error('检查设备连接失败:', error);
      this.disconnect();
      return false;
    }
  }

  /**
   * 初始化设备（用完后自动断开）
   */
  async init(): Promise<boolean> {
    try {
      const response = await this.sendMessage('InitDevs');
      
      if (response.ret !== 0) {
        //console.error('未检测到高拍仪设备');
        this.disconnect();
        return false;
      }

      //console.log('✅ 高拍仪初始化成功');
      this.disconnect(); // 初始化完立即断开
      return true;
    } catch (error) {
      //console.error('初始化失败:', error);
      this.disconnect();
      return false;
    }
  }

  /**
   * 获取设备状态（暂不支持）
   */
  async getDeviceStatus(): Promise<{
    video0: string;
    video1: string;
  }> {
    //console.warn('⚠️ WebSocket API 不支持直接获取设备状态');
    return {
      video0: 'unknown',
      video1: 'unknown',
    };
  }

  /**
   * 获取设备列表
   */
  async getDevices(): Promise<DeviceInfo[]> {
    try {
      const status = await this.getDeviceStatus();
      const devices: DeviceInfo[] = [];

      // 主摄像头
      if (status.video0 !== 'no') {
        devices.push({
          name: '主摄像头',
          index: 0,
          status: status.video0,
          online: true,
        });
      }

      // 副摄像头
      if (status.video1 !== 'no') {
        devices.push({
          name: '副摄像头',
          index: 1,
          status: status.video1,
          online: true,
        });
      }

      return devices;
    } catch (error) {
      //console.error('获取设备列表失败:', error);
      return [];
    }
  }

  /**
   * 获取设备型号（用完后自动断开）
   */
  async getDeviceModel(): Promise<string> {
    try {
      const camIdx = this.config.defaultCameraIndex;
      const response = await this.sendMessage('GetDeviceName', {
        device: camIdx,
      });
      const model = response.ret === 0 ? (response.value || '未知设备') : '未知设备';
      this.disconnect();
      return model;
    } catch (error) {
      //console.error('获取设备型号失败:', error);
      this.disconnect();
      return '未知设备';
    }
  }

  /**
   * 获取设备序列号（WebSocket API 不支持）
   */
  async getDeviceSerialNumber(): Promise<string> {
    //console.warn('⚠️ WebSocket API 不支持获取设备序列号');
    return '';
  }

  /**
   * 打开视频流（带回调）
   * @param cameraIndex 摄像头索引
   * @param callback 视频流回调函数，接收 base64 图片数据
   */
  async openVideoStream(
    cameraIndex: number,
    callback: (base64: string) => void
  ): Promise<boolean> {
    try {
      // 保存回调函数
      this.videoStreamCallback = callback;
      
      // 打开摄像头并启用数据回调
      const response = await this.sendMessage('OpenCamera', {
        device: cameraIndex,
        resolution: 0, // 默认使用最高分辨率
        datacallback: true, // 启用视频流回调
      });

      return response.ret === 0;
    } catch (error) {
      //console.error('打开视频流失败:', error);
      this.disconnect();
      return false;
    }
  }

  /**
   * 关闭视频流（关闭后断开连接）
   */
  async closeVideoStream(cameraIndex?: number): Promise<boolean> {
    try {
      const camIdx = cameraIndex ?? this.config.defaultCameraIndex;
      
      // 清除视频流回调
      this.videoStreamCallback = null;
      
      const response = await this.sendMessage('CloseCamera', {
        device: camIdx,
      });
      
      const success = response.ret === 0;
      this.disconnect(); // 关闭后断开连接
      return success;
    } catch (error) {
      //console.error('关闭视频失败:', error);
      this.disconnect();
      return false;
    }
  }

  /**
   * 兼容旧方法
   */
  async closeVideo(cameraIndex?: number): Promise<boolean> {
    return this.closeVideoStream(cameraIndex);
  }

  /**
   * 获取视频流URL（WebSocket 模式下返回特殊标识）
   */
  getVideoStreamUrl(cameraIndex?: number): string {
    return 'websocket-video-stream';
  }

  /**
   * 旋转视频（WebSocket API 不支持）
   */
  async rotateVideo(angle: number, cameraIndex?: number): Promise<boolean> {
    //console.warn('⚠️ WebSocket API 不支持旋转视频');
    return false;
  }

  /**
   * 确保摄像头已打开（内部方法，不断开连接，用于拍照）
   */
  private async ensureCameraOpen(cameraIndex: number): Promise<boolean> {
    try {
      // 尝试打开摄像头（不启用视频流回调）
      const response = await this.sendMessage('OpenCamera', {
        device: cameraIndex,
        resolution: 0, // 默认使用最高分辨率
        datacallback: false, // 拍照时不需要视频流回调
      });

      // 等待摄像头启动
      await new Promise((resolve) => setTimeout(resolve, 500));

      return response.ret === 0;
    } catch (error) {
      //console.error('打开摄像头失败:', error);
      return false;
    }
  }

  /**
   * 拍摄照片（核心方法）
   * 
   * @param cameraIndex 摄像头索引 (0=主摄像头, 1=副摄像头)
   * @param autoOpenCamera 是否自动打开摄像头，默认true
   * @param keepConnection 是否保持连接（视频流模式下为true），默认false
   */
  async capture(
    cameraIndex?: number,
    autoOpenCamera: boolean = true,
    keepConnection: boolean = false
  ): Promise<CaptureResult> {
    try {
      const camIdx = cameraIndex ?? this.config.defaultCameraIndex;
      const wasConnected = this.isConnected; // 记录之前是否已连接

      // 自动打开摄像头
      if (autoOpenCamera && !wasConnected) {
        const cameraOpened = await this.ensureCameraOpen(camIdx);
        if (!cameraOpened) {
          //console.warn('无法自动打开摄像头，尝试继续拍照...');
        }
      }
      
      const requestData = {
        imagepath: '', // 空字符串表示返回 base64
        colorize: this.config.colorMode,
        type: true, // true 表示拍照保存在图片列表
      };

      const response = await this.sendMessage('ScanImage', requestData);

      // 检查响应
      if (response.ret !== 0) {
        // 如果失败，尝试打开摄像头后重试
        //console.log('拍照失败，尝试打开摄像头并重试...');
        
        const cameraOpened = await this.ensureCameraOpen(camIdx);
        if (!cameraOpened) {
          if (!keepConnection && !wasConnected) {
            this.disconnect();
          }
          return {
            success: false,
            error: '无法打开摄像头',
          };
        }
        
        // 重试拍照
        const retryResponse = await this.sendMessage('ScanImage', requestData);
        
        if (retryResponse.ret !== 0) {
          if (!keepConnection && !wasConnected) {
            this.disconnect();
          }
          return {
            success: false,
            error: retryResponse.message || '拍摄失败',
          };
        }
        
        const result = this.processCaptureResponse(retryResponse);
        // 如果不需要保持连接且之前未连接，则断开
        if (!keepConnection && !wasConnected) {
          this.disconnect();
        }
        return result;
      }

      const result = this.processCaptureResponse(response);
      // 如果不需要保持连接且之前未连接，则断开
      if (!keepConnection && !wasConnected) {
        this.disconnect();
      }
      return result;
    } catch (error: any) {
      //console.error('拍摄失败:', error);
      // 发生错误时，如果不需要保持连接，则断开
      if (!keepConnection) {
        this.disconnect();
      }
      return {
        success: false,
        error: error.message || '拍摄失败',
      };
    }
  }

  /**
   * 处理拍照响应数据
   */
  private processCaptureResponse(response: WebSocketResponse): CaptureResult {
    const base64Data = response.value;
    if (!base64Data || base64Data.length === 0) {
      return {
        success: false,
        error: '拍摄失败，未获取到图片数据',
      };
    }

    // 确保Base64数据包含正确的前缀
    let imageData = base64Data;
    if (!imageData.startsWith('data:image')) {
      imageData = `data:image/jpeg;base64,${base64Data}`;
    }

    return {
      success: true,
      imageData,
      fileName: `capture_${Date.now()}.jpg`,
    };
  }

  /**
   * 连续拍摄（每次拍照都会自动断开连接）
   */
  async captureMultiple(
    count: number,
    cameraIndex?: number
  ): Promise<CaptureResult[]> {
    const results: CaptureResult[] = [];

    for (let i = 0; i < count; i++) {
      const result = await this.capture(cameraIndex);
      results.push(result);
      // 每次拍摄之间稍作延迟
      if (i < count - 1) {
        await new Promise((resolve) => setTimeout(resolve, 300));
      }
    }

    return results;
  }

  /**
   * 展平拍照（去手指、双页分离，用完后自动断开）
   */
  async captureWithFlat(options: {
    flat?: boolean;
    leftFilePath?: string;
    rightFilePath?: string;
    removeFinger?: boolean;
    doublePage?: boolean;
    cameraIndex?: number;
  }): Promise<{
    success: boolean;
    error?: string;
    mainImage?: string;
    leftImage?: string;
    rightImage?: string;
  }> {
    try {
      const requestData = {
        flag: options.flat ? 1 : 0,
        LeftImagePath: options.leftFilePath || '',
        RightImagePath: options.rightFilePath || '',
      };

      const response = await this.sendMessage('flattenScan', requestData);

      if (response.ret !== 1) {
        this.disconnect();
        return {
          success: false,
          error: response.message || '展平拍照失败',
        };
      }

      const result = {
        success: true,
        leftImage: response.LeftImageBase64
          ? `data:image/jpeg;base64,${response.LeftImageBase64}`
          : undefined,
        rightImage: response.RightImageBase64
          ? `data:image/jpeg;base64,${response.RightImageBase64}`
          : undefined,
      };
      
      this.disconnect(); // 拍照完成后断开连接
      return result;
    } catch (error: any) {
      //console.error('展平拍照失败:', error);
      this.disconnect();
      return {
        success: false,
        error: error.message || '展平拍照失败',
      };
    }
  }

  /**
   * 条码识别（WebSocket API 暂不支持）
   */
  async scanBarcode(timeout: number = 20): Promise<{
    success: boolean;
    error?: string;
    barcodes?: Array<{ barcodedata: string }>;
  }> {
    //console.warn('⚠️ 当前 WebSocket API 暂不支持条码识别');
    return {
      success: false,
      error: '当前 API 不支持条码识别',
    };
  }

  /**
   * 读取身份证（用完后自动断开）
   */
  async readIDCard(): Promise<{
    success: boolean;
    error?: string;
    idCardInfo?: IDCardInfo;
  }> {
    try {
      const response = await this.sendMessage('ReadIdCard');

      if (response.ret !== 0) {
        this.disconnect();
        return {
          success: false,
          error: response.message || '读取身份证失败',
        };
      }

      // 组装身份证信息
      const idCardInfo: IDCardInfo = {
        name: response.name || '',
        sex: response.sex || '',
        sexCode: '',
        nationCode: '',
        birthday: response.birth || '',
        address: response.address || '',
        cardID: response.number || '',
        issueOrgan: response.issue || '',
        validStart: response.begin || '',
        validEnd: response.end || '',
        strIDUID: '',
        appendMsg: '',
        photoBase64: response.photo || '',
        photoBase64_Z: response.photofront || '',
        photoBase64_F: response.photoback || '',
      };

      this.disconnect(); // 读取完成后断开连接
      return {
        success: true,
        idCardInfo,
      };
    } catch (error: any) {
      //console.error('读取身份证失败:', error);
      this.disconnect();
      return {
        success: false,
        error: error.message || '读取身份证失败',
      };
    }
  }

  /**
   * 获取指纹（WebSocket API 不支持）
   */
  async getFingerprint(timeout: number = 20): Promise<{
    success: boolean;
    error?: string;
    imageData?: string;
  }> {
    //console.warn('⚠️ WebSocket API 不支持指纹采集');
    return {
      success: false,
      error: 'WebSocket API 不支持指纹采集',
    };
  }

  /**
   * 设置图片质量
   */
  setQuality(quality: number) {
    this.config.quality = Math.max(0, Math.min(5, quality));
  }

  /**
   * 设置旋转角度
   */
  setRotate(angle: number) {
    const validAngles = [0, 90, 180, 270];
    if (validAngles.includes(angle)) {
      this.config.rotate = angle;
    }
  }

  /**
   * 设置颜色模式
   */
  setColorMode(mode: number) {
    const validModes = [0, 1, 2];
    if (validModes.includes(mode)) {
      this.config.colorMode = mode;
    }
  }

  /**
   * 断开连接并释放资源
   */
  disconnect(): void {
    try {
      // 清理消息处理器
      this.messageHandlers.clear();
      
      // 关闭 WebSocket 连接
      if (this.ws) {
        this.ws.close();
        this.ws = null;
      }
      
      this.isConnected = false;
      //console.log('🔌 高拍仪已断开连接');
    } catch (error) {
      //console.error('断开连接失败:', error);
    }
  }

  /**
   * 获取连接状态
   */
  getConnectionStatus(): boolean {
    return this.isConnected && this.ws?.readyState === WebSocket.OPEN;
  }
}

/**
 * 创建高拍仪实例（单例模式）
 */
let scannerInstance: LiangtianScanner | null = null;

/**
 * 获取高拍仪实例
 */
export function getScannerInstance(config?: ScannerConfig): LiangtianScanner {
  if (!scannerInstance) {
    scannerInstance = new LiangtianScanner(config);
  }
  return scannerInstance;
}

/**
 * 快速拍摄方法（推荐使用）
 * 
 * @param config 配置选项
 * @returns 拍摄结果
 * 
 * @example
 * ```typescript
 * const result = await quickCapture();
 * if (result.success) {
 *   //console.log('拍摄成功:', result.imageData);
 * } else {
 *   //console.error('拍摄失败:', result.error);
 * }
 * ```
 */
export async function quickCapture(
  config?: ScannerConfig
): Promise<CaptureResult> {
  try {
    const scanner = getScannerInstance(config);

    // 检查设备连接
    const isConnected = await scanner.checkConnection();
    if (!isConnected) {
      ElMessage.error('未检测到高拍仪设备，请检查设备连接和服务是否启动');
      return {
        success: false,
        error: '未检测到设备',
      };
    }

    // 拍摄
    const result = await scanner.capture();

    if (result.success) {
      ElMessage.success('拍摄成功');
    } else {
      ElMessage.error(result.error || '拍摄失败');
    }

    return result;
  } catch (error: any) {
    //console.error('快速拍摄失败:', error);
    ElMessage.error(error.message || '拍摄失败');
    return {
      success: false,
      error: error.message || '拍摄失败',
    };
  }
}

/**
 * 批量拍摄方法
 * 
 * @param count 拍摄数量
 * @param config 配置选项
 * @returns 拍摄结果数组
 */
export async function quickCaptureMultiple(
  count: number,
  config?: ScannerConfig
): Promise<CaptureResult[]> {
  try {
    const scanner = getScannerInstance(config);

    // 检查设备连接
    const isConnected = await scanner.checkConnection();
    if (!isConnected) {
      ElMessage.error('未检测到设备');
      return [];
    }

    // 批量拍摄
    ElMessage.info(`开始连续拍摄 ${count} 张...`);
    const results = await scanner.captureMultiple(count);

    const successCount = results.filter((r) => r.success).length;
    ElMessage.success(`拍摄完成：成功 ${successCount}/${count} 张`);

    return results;
  } catch (error: any) {
    //console.error('批量拍摄失败:', error);
    ElMessage.error(error.message || '批量拍摄失败');
    return [];
  }
}

/**
 * 快速读取身份证
 */
export async function quickReadIDCard(config?: ScannerConfig): Promise<{
  success: boolean;
  error?: string;
  idCardInfo?: IDCardInfo;
}> {
  try {
    const scanner = getScannerInstance(config);

    // 检查设备连接
    const isConnected = await scanner.checkConnection();
    if (!isConnected) {
      ElMessage.error('未检测到高拍仪设备');
      return {
        success: false,
        error: '未检测到设备',
      };
    }

    const result = await scanner.readIDCard();

    if (result.success) {
      ElMessage.success('读取身份证成功');
    } else {
      ElMessage.error(result.error || '读取身份证失败');
    }

    return result;
  } catch (error: any) {
    //console.error('读取身份证失败:', error);
    ElMessage.error(error.message || '读取身份证失败');
    return {
      success: false,
      error: error.message || '读取身份证失败',
    };
  }
}

/**
 * 快速扫描条码
 */
export async function quickScanBarcode(
  timeout: number = 20,
  config?: ScannerConfig
): Promise<{
  success: boolean;
  error?: string;
  barcodes?: Array<{ barcodedata: string }>;
}> {
  try {
    const scanner = getScannerInstance(config);

    // 检查设备连接
    const isConnected = await scanner.checkConnection();
    if (!isConnected) {
      ElMessage.error('未检测到高拍仪设备');
      return {
        success: false,
        error: '未检测到设备',
      };
    }

    ElMessage.info('正在识别条码，请将条码放置在扫描区域...');
    const result = await scanner.scanBarcode(timeout);

    if (result.success) {
      const count = result.barcodes?.length || 0;
      ElMessage.success(`识别成功，共识别到 ${count} 个条码`);
    } else {
      ElMessage.error(result.error || '条码识别失败');
    }

    return result;
  } catch (error: any) {
    //console.error('扫描条码失败:', error);
    ElMessage.error(error.message || '扫描条码失败');
    return {
      success: false,
      error: error.message || '扫描条码失败',
    };
  }
}

/**
 * 检查当前环境协议
 */
export function getCurrentProtocol(): 'ws' {
  return 'ws';
}

/**
 * 获取推荐的高拍仪服务地址
 */
export function getRecommendedScannerUrl(): string {
  return 'ws://127.0.0.1:9000';
}

/**
 * 测试 WebSocket 连接
 */
export async function testWebSocketConnection(): Promise<{
  success: boolean;
  error?: string;
  protocol?: string;
}> {
  return new Promise((resolve) => {
    const wsUrl = getRecommendedScannerUrl();
    const protocol = getCurrentProtocol();
    
    try {
      const ws = new WebSocket(wsUrl);
      
      const timeout = setTimeout(() => {
        ws.close();
        resolve({
          success: false,
          error: '连接高拍仪服务超时',
          protocol: protocol,
        });
      }, 3000);

      ws.onopen = () => {
        clearTimeout(timeout);
        ws.close();
        resolve({
          success: true,
          protocol: protocol,
        });
      };

      ws.onerror = () => {
        clearTimeout(timeout);
        resolve({
          success: false,
          error: `无法连接到高拍仪服务 (${wsUrl})，请确保服务已启动`,
          protocol: protocol,
        });
      };
    } catch (error) {
      resolve({
        success: false,
        error: error instanceof Error ? error.message : '连接失败',
        protocol: protocol,
      });
    }
  });
}

/**
 * 检查并提示 WebSocket 连接状态
 */
export async function checkAndPromptConnection(): Promise<boolean> {
  try {
    const result = await testWebSocketConnection();
    
    if (!result.success) {
      ElMessage({
        message: result.error || '无法连接高拍仪服务',
        type: 'warning',
        duration: 5000,
        showClose: true,
      });
      return false;
    }
    
    return true;
  } catch (error: any) {
      ElMessage({
      message: error.message || '连接测试失败',
        type: 'error',
      duration: 5000,
        showClose: true,
      });
    return false;
  }
}

/**
 * WebSocket 环境使用说明
 * 
 * 使用良田高拍仪 WebSocket API 需要完成以下步骤：
 * 
 * 1. 确保良田高拍仪服务已启动（LTService.exe 或良田服务程序）
 * 
 * 2. WebSocket 协议：
 *    - 使用 ws:// 协议，默认端口 9000
 *    - 连接地址：ws://127.0.0.1:9000
 * 
 * 3. 资源管理：
 *    - 每次使用时自动建立连接
 *    - 操作完成后自动断开连接
 *    - 节省系统资源
 * 
 * 4. API 特点：
 *    - 使用 function 字段指定命令
 *    - 响应使用 ret 字段（0=成功，其他=失败）
 *    - 返回值在 value 字段中
 *    - 不支持视频流预览（直接拍照即可）
 */

